使机器运转起来

泛化

泛化是机器学习的首要目标，甚至是唯一目标。由于偏差和方差之间是此消彼长的关系，因此如何实现二者之间的最优是个难题。在这过程中，机器学习有三个最重要的方式以实现目标。

（1）正则化

在我们进行预测中，会用到最小二乘法。基于高斯-马尔可夫定理，我们很容易得到无偏估计，但无偏估计并不一定等于最优估计量。以最小二乘法建模时，我们的偏差为0，方差为${\sigma }^2$$\sigma^2$。当模型过于复杂，${\sigma }^2$$\sigma^2$会变得非常大，此时模型处于过拟合状态，泛化性能很低。因此需要通过引入惩罚项牺牲无偏性以减小方差，这个思路就叫做正则化。正则一词的本意为“使某物变得规则、标准或规范”，正则化就是使过拟合的模型变得更简单、规范，以避免模型在训练数据上学习到不必要的复杂性或噪声。

其中，最常用的正则化方式为岭回归和Lasso回归。具体来说，岭回归和Lasso回归都是在OLS的目标函数基础上加上惩罚项：

惩罚项是对过拟合模型的一种“惩罚”，目的是限制模型的自由度。试想一下，你在一个城市的路上开车，目标是找到一个最佳路径，但你不能在每个街道上都停下来（过拟合），你希望找到一个尽可能简短、平稳的路径来避免走冗余的弯路。惩罚项就像是在路径的每个转弯点施加了一个“罚款”，每次转弯越多（模型越复杂）就要支付更多的“罚款”，最终你会选择一个更加简单、平稳的路径。

（2）集成算法

简单来说，集成算法的核心就是通过一些方式提高算法的预测性能（力大砖飞），例如，进行多次有放回的抽样求平均值。

（3）深度学习法

以神经网络为例，进行多次嵌套。

特点与应用

特点

机器学习有以下几种优势与特点：

处理高维数据、处理非结构化数据、处理非线性关系、强调模型的泛化性能、对异质性估计重视、数据驱动。

应用

机器学习的主要应用范围：

预测、生成数据（将海量的非结构化数据处理成社会科学能够使用的结构数据）、因果识别。

经典回归算法

OLS回归算法

OLS基本原理

最小二乘法

OLS（Ordinary Least Squares）的思想极其简单，在一群散点间我们能够画出无数条直线，我们希望其中一条直线能够使所有点到直线的距离最短，即残差和最小。由于散点不规则地分布在直线的上下两侧，因此残差必然会出现正负值，而我们很难比较$-1+1=0$$-1+1=0$与$-0.5+0.5=0$$-0.5+0.5=0$之间谁的残差和更小，为此我们对残差取平方，比较其平方和大小。因为我们追求的是残差平方和最小，所以这个方法就叫做最小二乘法。

通过计算残差，即观测值与期望值之间的差距，使得残差平方和最小而形成一条拟合曲线，其目标函数为：

当OLS是BLUE（Best Linear Unbiased Estimator）时：

因此，即便通过OLS预测得到的估计系数是无偏的，但方差大的缺点依旧让该方法在预测性能上表现较差。当然，其优点在于简单易用、参数估计无偏性和有效性、估计参数容易解释（参数=特征变量对相应变量的边际影响）。

OLS算法的操作代码

我们用sklearn模块自带的糖尿病数据集进行演示，该数据集收集了442位糖尿病人的10个特征，用以预测糖尿病人的病情。

一般来说，使用python对OLS回归算法进行数据分析时，有六个步骤：

（1）导入模块并加载数据

首先，调用pandas、numpy和sklearn。

xxxxxxxxxx
7
1
# python演示代码
2

3
# 导入可能需要调用的包:sklearn, scipy, numpy, pandas
4
from sklearn.datasets import load_diabetes
5
import scipy
6
import numpy as np
7
import pandas as pd

接着从load_diabetes()加载数据，并查看数据特征。

xxxxxxxxxx
6
1
# 加载数据集
2
diabetes = load_diabetes()
3

4
# 查看特征数据维度
5
print(diabetes.data.shape)     # 特征矩阵
6
print(diabetes.target.shape)   # 目标向量

（2）指定特征变量和响应变量

示例中为糖尿病人的数据集，一共442条数据。其中，data是数据集中的特征变量，一共10个，类型为NumPy数组；target为数据集中的目标变量，同样也是NumPy数组。

xxxxxxxxxx
10
1
# 特征变量为X
2
X = diabetes.data
3
print(X.shape)
4
print(diabetes.feature_names)
5
print(diabetes.data)
6

7
# 定义响应变量为y
8
y = diabetes.target
9
print(y.shape)
10
print(diabetes.target)

（3）划分训练集和测试集

为了强化算法的预测性能，机器学习会将样本划分成训练集和测试集。首先，机器学习会在训练集中训练模型，得到参数估计值，然后将训练后的模型应用到测试集中，用于观察模型的预测能力。

一般来说，训练集和测试集的划分没有客观统一的标准，我们可以通过test_size进行调节。如果不指定test_size，则会默认训练集和测试集比为3:1。

xxxxxxxxxx
9
1
# 从sklearn中进一步调用train_test_split，用以划分训练集和测试集
2
from sklearn.model_selection import train_test_split
3

4
# 划分测试集和训练集，并将训练集和测试集的规模比例定义为0.7:0.3（默认是3:1）
5
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size= 0.3, random_state= 1) # random_state是随机值，由于计算机伪随机，因此为了能够复现结果，这里设置为1
6

7
# 分别打印训练集和测试集中的特征变量和响应变量的数据结构
8
print(X_train.shape, y_train.shape)
9
print(X_test.shape, y_test.shape)

（4）使用训练集训练模型

在划分完训练集和测试集后，使用训练集来建模。首先定义一个算法，即实例化一个对象，在本示例中为建立线性回归模型。然后利用训练集X_train和y_train来训练这个模型。

xxxxxxxxxx
14
1
# 从sklearn中调用LinearRegression，并用这个线性模型来拟合
2
from sklearn.linear_model import LinearRegression
3
from sklearn import metrics
4

5
# 默认所有超参数
6
# 实例化一个对象
7
linreg = LinearRegression()
8

9
# 调用实例方法fit()
10
linreg.fit(X_train, y_train)  # 对应stata中的reg y X
11

12
# 打印计算的结果：模型估计的参数和截距
13
print("参数：", linreg.coef_)
14
print("截距：", linreg.intercept_)

（5）评估模型预测性能

训练完模型后，需要评估模型的预测性能。对于线性回归而言，一般使用测试集上的均方误差（MSE）或均方误差平方根（RMSE）。其中，$MSE(\hat{y})=\mathbb{E}(\hat{y}-y{)}^2$$MSE(\hat y)=\mathbb{E}(\hat y-y)^2$而$RMSE=\sqrt{MSE}$$RMSE =\sqrt{MSE}$。MSE和RMSE越小，则算法的预测性能越好。

xxxxxxxxxx
12
1
# 根据训练集和测试集中的特征变量计算出预测值
2
y_pred = linreg.predict(X_test)
3
y_pred1 = linreg.predict(X_train)
4
print(y_pred[0:5])
5
print(y_pred1[0:5])
6

7
# 用scikit-learn计算MSE
8
print("MSE for train sample：", metrics.mean_squared_error(y_train, y_pred1))
9
print("MSE for test sample：", metrics.mean_squared_error(y_test, y_pred))
10

11
# 用scikit-learn计算RMSE
12
print("RMSE for test sample：", np.sqrt(metrics.mean_squared_error(y_test, y_pred)))

（6）调整参数选择最优模型

一般而言，为了得到预测性能最佳的模型需要多次调整超参训练模型，每次都会得到一个MSE或RMSE。将这些进行对比，选择MSE或RMSE最小以获得最终训练的模型。在示例中，我们将特征变量转变成dataframe后，选择bmi、bp、s5这几个特征，观察是否会提升模型的预测性能。

xxxxxxxxxx
30
1
import pandas as pd
2
import numpy as np
3
from sklearn.linear_model import LinearRegression
4
from sklearn.datasets import load_diabetes
5
from sklearn.model_selection import train_test_split
6
from sklearn import metrics
7

8
# 加载数据
9
diabetes = load_diabetes()
10

11
# 重新对数据进行指定
12
X_full = pd.DataFrame(diabetes.data, columns=diabetes.feature_names)
13
y = diabetes.target
14

15
# 只选择几个特征
16
X = X_full[['bmi', 'bp', 's5']]
17

18
# 重复之前的步骤
19
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size= 0.3, random_state= 1)
20
linreg = LinearRegression()
21
linreg.fit(X_train, y_train)
22

23
# 拟合模拟测试集
24
y_pred = linreg.predict(X_test)
25

26
# 用scikit-learn计算MSE
27
print("MSE for test sample:", metrics.mean_squared_error(y_test, y_pred))
28

29
# 用scikit-learn计算RMSE
30
print("RMSE for test sample:", np.sqrt(metrics.mean_squared_error(y_test, y_pred)))

岭回归算法

当我们需要面临的处理数据不再是简单的调查数据，而是海量大数据与高维数据，甚至出现变量数量超过样本的情况时，再使用OLS回归算法会存在十分严重的共线性问题。因为$\hat{\beta }=(X^{\prime }X{)}^{-1}{X}^{\prime }Y$$\hat \beta=(X'X)^{-1}X'Y$，$\hat{\beta }$$\hat \beta$的求解依赖于$(X^{\prime }X{)}^{-1}$$(X'X)^{-1}$是否可逆。在多重共线性的情况下，$X$$X$存在线性相关，即$(X^{\prime }X)$$(X'X)$是个奇异矩阵不再可逆，因而$\hat{\beta }$$\hat \beta$不存在唯一解。想要规避该问题，我们需要进行正则化。

岭回归算法的基本原理

（1）岭回归算法的原理

在总论的泛化部分，我们提到过岭回归的目标函数为：

等式右边第二项是对所有待估计系数$\beta$$\beta$求平方和（L2范数惩罚项）乘上一个调节参数（超参数）$\lambda$$\lambda$。其中，调节参数$\lambda \ge 0$$\lambda\ge0$。参考OLS的思想，我们需要使目标函数最小，因此$\lambda$$\lambda$越大表明对模型复杂程度的惩罚力度越大，会更大程度的收缩系数$\beta$$\beta$的估计值；当$\lambda \to \mathrm{\infty }$$\lambda\to \infty$时，惩罚力度极大，系数估计值$\beta \to 0$$\beta \to 0$；当$\lambda =0$$\lambda=0$时，岭回归算法会回退到OLS回归算法。

我们将目标函数重写成：

为找到最小化目标函数，我们对$\beta$$\beta$求导并令其等于0:

由于$\lambda I$$\lambda I$为正定矩阵，$X^{T}X+\lambda I$$X^TX+\lambda I$可逆，因此$\beta$$\beta$存在唯一解。

为了更直观理解惩罚含义，我们以几何形式进行解释。公式12可以等价改写成：

其中，$t\ge 0$$t \ge 0$。换言之，我们相当于需要在估计系数平方和不大于$t$$t$这个条件下，根据最小化残差平方和求解参数。在二维空间下，约束条件等同于以$\sqrt{t}$$\sqrt t$为半径的圆，即${\beta }_1^2+{\beta }_2^2=t$$\beta_1^2+\beta_2^2=t$。

残差平方和的等值线可以表示为：

其中，C是一个常数，表示残差平方和的某个固定值。因而$\beta$$\beta$的所有可能取值的几何图形是一个椭圆形。

岭回归几何图形

从图中我们可以更直观理解，如果要在圆形组成的可行解中将残差平方和最小化，那么最优解一定产生于圆形曲线与椭圆形曲线的交点，即岭回归的系数估计值。

同时，从图中也可以看到，在加入惩罚项后系数会向0收缩，但并不至于收缩至0。

（2）岭回归算法的预测能力

从估计值可知，${\hat{\beta }}_{ridge}={\hat{\beta }}_{ols}/(1+\lambda )$$\hat \beta_{ridge}=\hat \beta_{ols}/(1+\lambda)$，即在加入惩罚项的情况下系数一定是有偏的。但相对而言，其系数的方差会缩小至${\sigma }^2/(1+\lambda )$$\sigma^2/(1+\lambda)$。也就是说，岭回归算法相较于OLS算法牺牲了模型的无偏性，降低了模型的方差，从而得到更好的样本之外的预测能力。

（3）岭回归的优缺点

岭回归算法相较于OLS回归算法有几个突出的优点：

解决多重共线性问题、防止过度拟合、能够处理高维数据集、易于实现与计算。

但同时，岭回归也有一些无法忽视的缺陷：

调节参数选择困难（$\lambda$$\lambda$值究竟取多少最合适）、假设线性关系、不能自动选择变量（Lasso算法的优势）。

岭回归算法的操作代码

简单来说，岭回归算法相对于OLS算法只是增加了L2惩罚项，因此操作步骤与OLS回归算法几乎一致。

（1）导入模块并加载数据

xxxxxxxxxx
14
1
# python演示代码
2

3
# 导入可能需要调用的包:sklearn, scipy, numpy, pandas
4
from sklearn.datasets import load_diabetes
5
import scipy
6
import numpy as np
7
import pandas as pd
8

9
# 加载数据集
10
diabetes = load_diabetes()
11

12
# 查看特征数据维度
13
print(diabetes.data.shape)     # 特征矩阵
14
print(diabetes.target.shape)   # 目标向量

（2）指定特征变量和响应变量

在岭回归算法中，我们一样使用OLS中演示的例子。

xxxxxxxxxx
10
1
# 特征变量为X
2
X = diabetes.data
3
print(X.shape)
4
print(diabetes.feature_names)
5
print(diabetes.data)
6

7
# 定义响应变量为y
8
y = diabetes.target
9
print(y.shape)
10
print(diabetes.target)

（3）划分训练集和测试集

在示例中，我们将训练集和测试集默认为3:1，同时为了方便复现，随机状态random_state我们设置成0（实际上设置成任何整数都可行）。

xxxxxxxxxx
10
1
# 从sklearn中进一步调用train_test_split，用以划分训练集和测试集
2
from sklearn.model_selection import train_test_split
3
from sklearn.linear_model import Ridge
4

5
# 划分测试集和训练集，并将训练集和测试集的规模默认3:1
6
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state= 0)
7

8
# 分别打印训练集和测试集中的特征变量和响应变量的数据结构
9
print(X_train.shape, y_train.shape)
10
print(X_test.shape, y_test.shape)

（4）使用训练集训练模型

在使用岭回归算法时，我们需要设定调节参数的取值，即$\lambda$$\lambda$值的大小。在示例中，我们暂时将超参数设定为2，然后使用训练集数据进行模型训练。最后输出岭回归的测试性能得分、系数估计值和常数项。

xxxxxxxxxx
9
1
# 指定正则化参数，这里暂时设定为2。之后用岭回归算法对数据进行拟合
2
# 正则化必须是正浮点数
3
ridge = Ridge(alpha= 2)
4
ridge.fit(X_train, y_train)
5

6
# 打印岭回归算法的测试性能得分、参数估计值和常数项
7
print(ridge.score(X_train, y_train))
8
print(ridge.coef_)
9
print(ridge.intercept_)

（5）评估模型预测性能

与OLS算法类似，岭回归算法同样通过MSE或RMSE来判断训练模型的测试性能。

xxxxxxxxxx
10
1
# 使用验证集进行性能测试
2
from sklearn import metrics
3

4
y_pred = ridge.predict(X_test)
5

6
# 用scikit-learn计算MSE
7
print("MSE for test sample:", metrics.mean_squared_error(y_test, y_pred))
8

9
# 用scikit-learn计算RMSE
10
print("RMSE for test sample:", np.sqrt(metrics.mean_squared_error(y_test, y_pred)))

（6）调整参数选择最优模型

岭回归算法的调参过程与OLS算法类型，目的是获得MSE或RMSE最小的预测模型。在岭回归算法中，我们主要通过调整调节参数$\lambda$$\lambda$。一般来说，我们会根据个人研究的需求设置一系列可能取值的列表，然后观察每一个取值对应的MSE或RMS的变化和数值大小，从而选择最优模型。

xxxxxxxxxx
15
1
from sklearn import linear_model
2

3
# 划分测试集和训练集，并设置随机状态
4
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state= 0)
5

6
# 建立一个备选参数的列表
7
alphas = [0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000]
8
scores = []
9

10
# 循坏计算每一个参数对应的预测结果
11
for i, alpha in enumerate(alphas):
12
    ridge = Ridge(alpha=alpha)
13
    ridge.fit(X_train, y_train)
14
    scores.append(ridge.score(X_test, y_test))
15
print(scores)

Lasso回归算法

在面对高维数据时，我们会想在大量的特征变量中筛选出那些最能解释响应变量的特征变量。这一需求催生出了Lasso（Least Absolute Shrinkage and Selection Operator）回归算法。

Lasso回归算法的基本原理

（1）Lasso回归算法的原理

在总论的正则化部分我们指出，Lasso回归算法同样也是在OLS回归算法的基础上加入惩罚项。但与岭回归算法不同，Lasso回归中不使用L2范数惩罚项，而是变更成L1范数惩罚项：

等式右边第二项是对所有待估计系数$\beta$$\beta$求绝对值和（L1范数惩罚项）乘上一个调节参数$\lambda$$\lambda$。其中，调节参数$\lambda \ge 0$$\lambda\ge0$，当$\lambda =0$$\lambda=0$时，岭回归算法会回退到OLS回归算法。

根据链式法则，我们对L1范数惩罚项进行求导：

因此，目标函数在${\beta }_j=0$$\beta_j=0$处不可微，只能使用梯度下降法进行求解。正是因为不可微性使得Lasso估计产生稀疏解，导致一些系数为0，从而实现变量选择。

为了更直观理解，我们从几何图形的角度展示Lasso回归算法挑选变量的功能。我们将公式20等价成：

在二维空间下，约束条件变为$|{\beta }_1|+|{\beta }_2|=t$$|\beta_1|+|\beta_2|=t$，即一个以原点为中心，边长为$\sqrt{t^2+t^2}=\sqrt{2}t$$\sqrt{t^2+t^2}=\sqrt{2}t$的正方形。

残差平方和的等值线几何图形依然是个椭圆形。

Lasso回归几何图形

从图中我们可以更直观的理解，如果要在正方形组成的可行解中将残差平方和最小化，那么最优解一定产生于正方形顶点与椭圆形曲线的交点，即Lasso回归的系数估计值。

在图中的情况下，${\beta }_1=0$$\beta_1=0$，因此可以筛除变量$x_1$$x_1$。基于此，Lasso回归算法能够通过筛选对模型没有帮助的变量，以提高预测性能。

（2）Lasso回归算法的优缺点

Lasso回归算法相较于OLS回归算法和岭回归算法有一些优点：

特征选择、可解释性强、能够处理大规模模型数据、稳健性强、可以与其他算法相结合。

当然，Lasso回归算法也存在一些缺点：

参数调节、只适用于线性关系、估计系数的偏向、注意力不平衡。

Lasso回归算法的操作代码

与岭回归算法一样，Lasso回归也有六个操作步骤：

（1）导入模块和加载数据

xxxxxxxxxx
14
1
# python演示代码
2

3
# 导入可能需要调用的包:sklearn, scipy, numpy, pandas
4
from sklearn.datasets import load_diabetes
5
import scipy
6
import numpy as np
7
import pandas as pd
8

9
# 加载数据集
10
diabetes = load_diabetes()
11

12
# 查看特征数据维度
13
print(diabetes.data.shape)     # 特征矩阵
14
print(diabetes.target.shape)   # 目标向量

（2）指定特征变量和响应变量

xxxxxxxxxx
10
1
# 特征变量为X
2
X = diabetes.data
3
print(X.shape)
4
print(diabetes.feature_names)
5
print(diabetes.data)
6

7
# 定义响应变量为y
8
y = diabetes.target
9
print(y.shape)
10
print(diabetes.target)

（3）划分训练集和测试集

xxxxxxxxxx
6
1
# 划分测试集和训练集，并将训练集和测试集的规模默认3:1
2
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state= 1)
3

4
# 分别打印训练集和测试集中的特征变量和响应变量的数据结构
5
print(X_train.shape, y_train.shape)
6
print(X_test.shape, y_test.shape)

（4）使用训练集训练模型

xxxxxxxxxx
11
1
# 指定正则化参数，这里暂时设定为2
2
from sklearn.linear_model import Lasso
3
lasso = Lasso(alpha= 2)
4

5
# 用Lasso回归算法进行模拟
6
lasso.fit(X_train,y_train)
7

8
# 打印Lasso回归算法的测试性能得分、参数估计值和常数项
9
print(lasso.score(X_train, y_train))
10
print(lasso.coef_)
11
print(lasso.intercept_)

（5）评估模型预测性能

xxxxxxxxxx
9
1
# 使用验证集进行性能测试
2
from sklearn import metrics
3

4
y_pred = lasso.predict(X_test)
5
# 用scikit-learn计算MSE
6
print("MSE for test sample:", metrics.mean_squared_error(y_test, y_pred))
7

8
# 用scikit-learn计算RMSE
9
print("RMSE for test sample:", np.sqrt(metrics.mean_squared_error(y_test, y_pred)))

（6）调整参数选择最优模型

xxxxxxxxxx
13
1
# 划分测试集和训练集，并设置随机状态
2
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state= 1)
3

4
# 建立一个备选参数的列表
5
alphas = [0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000]
6
scores = []
7

8
# 循坏计算每一个参数对应的预测结果
9
for i, alpha in enumerate(alphas):
10
    lasso = Lasso(alpha=alpha)  # 使用Lasso回归
11
    lasso.fit(X_train, y_train)
12
    scores.append(lasso.score(X_test, y_test)) 
13
print(scores)

算法调参

在机器学习中，为了寻找最优模型，我们需要选择最优参数。一般来说，机器学习的常见调参方式包括验证集法和交叉验证法。

验证集法

验证集法就是我们前边提及的，将样本数据分为训练集和测试集。该方法简单易懂、节约开支，但同时存在数据利用率低等缺点。并且，如果面对的未知数据是训练集中未出现过的，该模型的预测性能将会严重降低。

交叉验证法

交叉验证法的基本思想非常简单，通过重复使用数据实现模型稳定：把给定的数据进行切分，将切分的数据集组合成训练集和测试集，并在此基础上进行反复训练、测试和模型选择。

机器学习中会大量使用K折交叉检验来度量测试误差，以K=10，10折交叉验证法为例：

步骤一、将样本中数据随机进行10等分（形成大致相等的10个子集）。

步骤二、将其中1个子集作为验证集（测试集），其余9个子集都作为训练集。进行模型的训练、评估、验证预测并计算MSE和RMSE。

步骤三、重复步骤二10次，直到每个子集都被作为验证集。

步骤四、将所有验证集的MSE进行平均，即“交叉验证误差”（CVE）作为对测试误差的估计。

K折交叉检验的优点在于减小了验证集法的随机性和波动性，增加了模型评估的稳定性和准确性，让所有数据都有机会进入训练集。除了K折交叉检验法外，在样本量较小时还可使用留一交叉检验法，当然，其本质依旧是k=n的n折交叉检验法。其中，n为样本容量。换言之，将样本数据等分为n折，每折仅包含一个样本，因此不在具有随机性。

岭回归和Lasso回归的调参

在岭回归和Lasso回归算法中，当$\lambda =0$$\lambda=0$时，算法会退化为OLS回归算法；当$\lambda \to \mathrm{\infty }$$\lambda \to \infty$时，估计参数$\beta$$\beta$会趋于0。因此，最优$\lambda$$\lambda$会分布在$[0,{\lambda }_{max}]$$[0,\lambda_{max}]$中。由于交叉检验法考量的是MSE，而MSE是凸函数，即：

MSE是个二次函数。此外，L1范数惩罚项和L2范数惩罚项均为凸函数。因此，$[0,{\lambda }_{max}]$$[0,\lambda_{max}]$中，必然会有一点使得$CV(\lambda )$$CV(\lambda)$达到最小值，此点就是最优超参$\lambda$$\lambda$。

算法调参的操作代码

我们将介绍几种算法调参的具体操作步骤。

循环寻找最优超参

（1）导入可能用到的模块，并加载数据

xxxxxxxxxx
18
1
import matplotlib.pyplot as plt
2
import numpy as np
3
from sklearn import datasets
4
from sklearn import linear_model 
5
from sklearn.linear_model import Lasso
6
from sklearn.model_selection import train_test_split
7

8
# 加载数据diabetes
9
diabetes = datasets.load_diabetes()
10

11
# 指定特征变量和响应变量
12
X = diabetes.data
13
y = diabetes.target
14
print(X.shape)
15
dir(diabetes)
16

17
# 划分训练集和测试集
18
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 1)

（2）先使用默认超参，观察模型的预测性能

xxxxxxxxxx
6
1
# 默认超参
2
lasso = Lasso()
3
lasso.fit(X_train, y_train)
4
print("权重向量:%s, b的值为:%.2f" % (lasso.coef_, lasso.intercept_))
5
print("损失函数的值:%.2f" % np.mean((lasso.predict(X_test)-y_test) ** 2))
6
print("预测性能得分:%.2f" % lasso.score(X_test, y_test))

（3）设置一系列备选的超参集，然后通过循环的方式计算每个超参对应的预测性能

xxxxxxxxxx
10
1
# 通过循环，寻找最优参数
2
X_train, X_test, y_train, y_test = train_test_split(diabetes.data, diabetes.target, test_size = 0.25, random_state = 1)
3
alphas = [0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000]
4
scores = []
5

6
for i, alpha in enumerate(alphas):
7
    lasso = Lasso(alpha=alpha)
8
    lasso.fit(X_train, y_train)
9
    scores.append(lasso.score(X_test, y_test))
10
print(scores)

（4）将每个参数对应的预测解出，并可视化

xxxxxxxxxx
9
1
# 可视化结果
2
fig = plt.figure()
3
ax = fig.add_subplot(1, 1, 1)
4
ax.plot(alphas, scores)
5
ax.set_xlabel(r"$\alpha$")
6
ax.set_ylabel(r"score")
7
ax.set_xscale("log")
8
ax.set_title("Lasso")
9
plt.show()

交叉验证选择超参

（1）导入可能用到的模块和数据集，采用10折交叉验证法，并设置一组备选的超参集（初始为0.01、最终为100、一共包含100个数的等比数列）

xxxxxxxxxx
13
1
import matplotlib.pyplot as plt
2
import numpy as np
3
from sklearn import datasets
4
from sklearn.linear_model import Lasso
5
from sklearn.model_selection import KFold
6
from sklearn.linear_model import LassoCV
7

8
#加载数据
9
diabetes = datasets.load_diabetes()
10
kfold = KFold(n_splits = 10, shuffle = True, random_state = 20)
11
alphas = np.logspace(-2, 2, 100)
12
print("First 10 alphas:", alphas[0:10])
13
print("Last 10 alphas:", alphas[-10:])

（2）采用10折验证法，在备选超参中选择最优参数

xxxxxxxxxx
8
1
# 交叉验证法寻找最优参数
2

3
diabetes = datasets.load_diabetes()
4
kfold = KFold(n_splits = 10, shuffle = True, random_state = 20)
5
alphas = np.logspace(-2, 2, 100)
6
model = LassoCV(alphas = alphas, cv = kfold)
7
model.fit(diabetes.data, diabetes.target)
8
print("Optimal alpha:", model.alpha_)

重要特征选择

（1）导入可能用到的模块并加载数据集

xxxxxxxxxx
15
1
import matplotlib.pyplot as plt
2
import numpy as np
3
from sklearn import datasets
4
from sklearn.linear_model import Lasso
5
from sklearn.model_selection import KFold
6
from sklearn.linear_model import LassoCV
7
import pandas as pd
8
from sklearn.preprocessing import StandardScaler
9

10
# 加载数据
11
diabetes = datasets.load_diabetes()
12
scaler = StandardScaler()
13
X = scaler.fit_transform(diabetes["data"])
14
Y = diabetes["target"]
15
names = diabetes["feature_names"]

（2）采用10折交叉验证，并设置一组备选的超参集（初始为0.01、最终为100、一共包含100个数的等比数列）

xxxxxxxxxx
4
1
kfold = KFold(n_splits = 10, shuffle = True, random_state = 30)
2
alphas = np.logspace(-2, 2, 100)
3
print("First 10 alphas:", alphas[0:10])
4
print("Last 10 alphas:", alphas[-10:])

（3）交叉验证，在备选超参中选择最优参数

xxxxxxxxxx
3
1
model = LassoCV(alphas = alphas, cv = kfold)
2
model.fit(X, Y)
3
print("Optimal alpha:", model.alpha_)

（4）查看模型最终选择和剔除了几个特征变量

xxxxxxxxxx
4
1
# 输出模型最终选择了几个特征变量，剔除了几个特征变量
2
import pandas as pd
3
coef = pd.Series(model.coef_, index = names)
4
print("Lasso picked " + str(sum(coef != 0)) + " variables and eliminated the other " + str(sum(coef == 0)) + " variables")

（5）通过画图展示各变量的重要程度

xxxxxxxxxx
12
1
import matplotlib.pyplot as plt
2

3
# 提取系数值最大和最小的三个特征
4
imp_coef = pd.concat([coef.sort_values().head(3),
5
                     coef.sort_values().tail(3)])
6
print(imp_coef)
7

8
# 绘制每个特征变量的估计值条形图
9
plt.rcParams['figure.figsize'] = (8.0, 10.0)
10
coef.plot(kind = "barh")
11
plt.title("Coefficients in the Lasso Model1")
12
plt.show()

经典分类算法

分类算法是一种用于将数据分为不同类别或标签的算法。其中，机器学习的分类算法可分为有监督和无监督。在总论部分我们提到，有监督机器学习分类算法是指，在训练过程，使用带有标签的数据样本进行学习，每个数据样本都有一个已知的标签或类别，例如“是”或“否”，“好”或“坏”。有监督学习的目的就是通过学习数据样本与标签之间的关系，建立预测新数据样本标签的模型，常见的算法包括逻辑回归、决策树、随机森林、支持向量机等。无监督机器学习算法则试图在没有明确指导的情况下，自动对数据进行分类或聚类，常见的无监督学习算法包括主成分分析、聚类分析等。无监督学习的优点在于能够在没有标签的情况下探索数据的内在结构，有助于对数据进行理解和预处理，同时，无监督学习的结果依赖于人的解释。

举个直观的应用场景。

例如，我们需要根据政府留言板来判断人们对政府的评价。 若留言数量不多，我们可以人工识别；但当留言数量超过10万甚至100万条时，人工识别费时费力。 为此，我们可以借助有监督学习算法，先从100万条留言中随机抽取1000条，手动打上标签（“好政府”或“坏政府”），再根据训练数据特征和标签之间的关系建立模型，最后让机器帮我们将剩余的99.9万条留言都打上标签。

无监督学习则是我们让机器自己根据一定算法寻找特征之间的联系。

例如，我们不知道留言板中的留言都讨论哪些话题。为此，我们可以采用LDA主题模型，通过词汇概率对留言主题进行推测。

在本章节中，我们主要介绍几种常用的有监督机器学习算法，而无监督机器学习算法则会在后续章节中详细介绍。

K临近算法

K临近算法的基本原理

（1）K临近算法的原理

K临近算法（K-Nearnest Neighbors，KNN）的核心思想正如其名——近朱者赤，近墨者黑。

涛声依旧和学猫叫

涛声依旧

举个生活中的例子。

不同时代的音乐风格差异很大，假如我们知道《涛声依旧》是1990年代的流行歌，而《学猫叫》是2020年代的。当我们听到《再回首》时，会下意识认为它更贴近《涛声依旧》而非《学猫叫》，从而将其归类为90年代流行歌曲。

K临近算法便是根据未知样本和训练样本之间的距离，预测分类。具体步骤如下：

第一步，收集包含已知类别标签的训练数据集。

第二步，选择K值。K值是KNN算法的一个超参数，表示在分类时要考虑多少个最临近的样本。

第三步，计算距离。对于未知类别的新数据样本，在特征空间中计算其与训练数据集中每个样本之间的距离。常用的距离度量方法包括欧氏距离、曼哈顿距离、切比雪夫距离等。

第四步，确定最近邻。最近邻是指，在特征空间中距离目标样本最接近的样本点。

第五步，投票选择类别。根据K个最近邻的标签，投票决定新样本的类别。

（2）计算距离的选择

在不确定距离对结果影响的情况下，我们常用闵可夫斯基距离：

$p$$p$是闵可夫斯基指数，决定了距离的计算公式。

当$p=1$$p=1$时，变成曼哈顿距离：

当$p=2$$p=2$时，变成欧几里德距离（欧氏距离）：

当$p\to \mathrm{\infty }$$p \to \infty$时，变成切比雪夫距离：

除此之外，在遇到文本型数据时会使用余弦相似度：$\text{cos}(\theta )=\frac{x·y}{||x||||y||}$$\text{cos}(\theta)=\frac{x·y}{||x||||y||}$。在后续章节我们会进行更为详细的叙述。

总之，我们在使用KNN时需要依据应用场景，选择合适的距离公式。

（3）KNN操作注意事项和优缺点

在操作过程中，我们需要关注：

KNN的不同取值

第一、K值的选择。如图片所示，当K值取3时，绿点的预测结果为红；而K值取5时，则为蓝。换言之，K值的选取对结果影响很大。当采用最临近法（K值为1）时，偏差为0但方差很大，此时决策边界很不规则，导致过拟合；当K值取非常大时，决策边界过于光滑，无法捕捉数据中的信号，使得预测性能下降，导致欠拟合。因此，与经典回归算法的$\lambda$$\lambda$一样，我们需要通过交叉验证或网格搜索（穷举）进行调参来选择合适的K值。一般来说，K值取一个较小的数值，3-5较为合适。

第二、选择合适的距离度量方式。

第三、数据归一化。在使用KNN算法之前，通常需要对数据进行归一化，以避免某些特征对距离的计算产生过大影响。

第四、处理样本不平衡问题。当某些类别的数量较少时，需要考虑是否采取加权KNN算法，赋予不同的邻居样本不同权重。

诚然，KNN算法简单直观，但其依旧存在一些应用局限：

第一、KNN是懒惰学习算法。在KNN算法中，模型并不进行显式学习，而是将所有训练数据存储起来，直到需要预测时才根据距离计算以找到最接近的k个样本，进行投票或加权平均。

第二、KNN在高维空间很难找到邻居，会遇到“维度灾难”。因此，KNN算法要求样本容量n必须远大于特征向量的维度p。

第三、KNN对噪音变量不稳健。KNN算法无法区别对待对预测毫无关系的噪音变量，这会导致估计效率的降低。

K临近算法的操作代码

在示例中，我们会用到sklearn模块自带的鸢尾花分类数据。该数据包含150个样本，分为3类，每一类50个数据，每个数据包含4个特征，通过花萼长度、花萼宽度、花瓣长度、花瓣宽度来预测鸢尾花属于哪个种类（Setosa，Versicolor，Virginica）。我们会先导入数据，然后通过手动编写代码来实现K临近分类算法（帮助理解KNN如何实现），最后我们使用sklearn模块自带的KNN分类器实现分类。

加载数据和可能用到的模块

xxxxxxxxxx
17
1
# 鸢尾花可以被分为Setosa，Versicolor，Virginica三个品种，我们需要建立一个预测模型，用以对未知数据判定其类型
2
import numpy as np
3
import matplotlib.pyplot as plt
4
from sklearn import datasets
5
plt.rcParams['font.sans-serif'] = ['Heiti TC'] #  用来正常显示中文标签
6

7
# 准备数据集
8
iris = datasets.load_iris()
9
X = iris.data  # X对应样本的四个特征
10
Y = iris.target  # Y对应样本的分类标签
11

12
# Y中的原始数据为0,1,2。为了简化处理，将其变成二分类问题，所以针对Y=0,1的行，从这些行中取X的前两列
13
x = X[Y<2,:2]  # 从X样本数据中选择Y<2的数据，并选择X中的前两列特征（花萼长度和花萼宽度）
14
print(x.shape)
15
print('x:\n',x)
16
y = Y[Y<2]
17
print('y:\n',y)

手动实现KNN算法

（1）进行数据可视化

将Y=0的点标记为空心点，Y=1的点标记为实心点。横坐标为花萼长度，纵坐标为花萼宽度。我们随机标记某一点（5.6，3.2），之后判断它属于哪个颜色。

xxxxxxxxxx
13
1
# 绘制散点图
2
plt.scatter(x[y == 0, 0], x[y == 0, 1], color='red', label='Class 0')
3
plt.scatter(x[y == 1, 0], x[y == 1, 1], color='green', label='Class 1')
4

5
# 画出要预测的新数据点
6
x_1 = np.array([5.6, 3.2])
7
plt.scatter(x_1[0], x_1[1], color='blue', marker='x', s=100, label='New Point')
8

9
# 添加图例和标签
10
plt.xlabel(iris.feature_names[0])  # x轴特征名称
11
plt.ylabel(iris.feature_names[1])  # y轴特征名称
12
plt.legend()
13
plt.show()

（2）计算预测点到其他所有点的距离

在示例中，我们选择欧氏距离，计算预测点（x_1）到其他所有点的距离。

xxxxxxxxxx
7
1
# 采用欧氏距离计算预测点到其他点的距离
2
distances = [np.sqrt(np.sum((x_t-x_1)**2)) for x_t in x]
3

4
# 对上述距离组进行排序，并获取排序后的索引
5
d = np.sort(distances)
6
nearest = np.argsort(distances)
7
print(nearest)

（3）选择K值，确认最近邻并投票选择类别

在示例中，我们暂时将K取值为6，即根据预测点的6个最临近样本确定其颜色。

xxxxxxxxxx
15
1
# 选择6个临近
2
k = 6
3
topk_y = [y[i] for i in nearest[:k]]
4
print(topk_y)
5

6
from collections import Counter # 导入Counter计数工具
7

8
# 对topk_y进行统计，返回一个字典{类别:票数}
9
votes = Counter(topk_y)
10
print(votes)
11

12
# 获取投票最多的类别
13
predict_y, count = votes.most_common(1)[0]  # 直接解包得到预测的类别和票数
14
print(votes.most_common(1))  # 返回投票结果与具体票数
15
print(predict_y)  # 输出最终预测类别

使用KNN分类器实现分类算法

（1）加载数据导入可能用到的模块，并划分训练集和测试集

xxxxxxxxxx
7
1
from sklearn import datasets
2
from sklearn.model_selection import train_test_split
3
from sklearn.neighbors import KNeighborsClassifier
4
iris = datasets.load_iris()
5
x = iris.data
6
y = iris.target
7
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size= 0.25, random_state= 123)

（2）建立KNeighborsClassifier分类器并调用fit方法进行训练，最后调用predict方法使用模型预测并输出分类准确率

xxxxxxxxxx
6
1
knn_classifier = KNeighborsClassifier(n_neighbors = 5)  #设置5个邻居，即K=5
2
knn_classifier.fit(x_train, y_train)  # 训练模型
3
y_predict = knn_classifier.predict(x_test)  ## 在测试集中使用预测模型
4
scores = knn_classifier.score(x_test, y_test)  ## 计算准确率。准确率（accuracy）=（正确预测的样本数）/（总样本数量）
5

6
print('acc: {} scores: {}'.format(sum(y_predict == y_test) / len(y_test), scores))  #手动计算准确率

（3）进行调参

与岭回归算法和Lasso回归算法类似，K临近算法同样需要调整超参数来实现最优模型。对机器学习而言，参数可分为模型参数和超参数。其中，KNN没有模型参数，因此我们需要调整两个超参数——K值和权重。

在调参中，我们使用sklearn库中自带的digits数据集。这是一个经典的手写数据子图数据集，属于典型的分类问题。在这个数据集中包含了8$\times$$\times$8像素的手写数字图像，每个图像都是一个数字（0到9）。即，每个图像由64个特征组成，每个图像都对应一个数字标签，一共10个类别。

xxxxxxxxxx
53
1
# 加载数据、导入模块，指定特征变量、响应变量，划分训练集和测试集
2
from sklearn import datasets
3
from sklearn.model_selection import train_test_split, cross_val_score
4
from sklearn.neighbors import KNeighborsClassifier
5
from sklearn.model_selection import cross_val_score
6
from sklearn.metrics import make_scorer, f1_score
7

8
# 加载数据
9
digits = datasets.load_digits()
10
x = digits.data
11
y = digits.target
12
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25, random_state=123)
13

14
# 初始化
15
best_k = -1
16
best_score = 0
17
best_method = None  # 初始化为None，表示未找到最好的方法
18

19
# 寻找最好的K和weights
20
for method in ['uniform', 'distance']:  # weights默认是uniform，参数可以是uniform、distance。当然KNeighborsClassifier也可以自定义权重，比如def custom_weights(distances):return 1 / (distances + 1e-5)，之后将weights=custom_weights
21
    for i in range(1, 11):
22
        knn_clf = KNeighborsClassifier(n_neighbors=i, weights=method)
23
        cv_scores = cross_val_score(knn_clf, x_train, y_train, cv=10)  # 使用10折交叉验证来评估模型的性能
24
        mean_cv_score = cv_scores.mean()  # 计算交叉验证的平均得分
25
        if mean_cv_score > best_score:
26
            best_score = mean_cv_score
27
            best_k = i
28
            best_method = method
29

30
print('最好的K值:%d, 最好的准确率:%.4f, 最好的方法:%s' % (best_k, best_score, best_method))
31

32
# 用F1替换best_score进一步检验模型预测性能
33
# 初始化
34
best_k = -1
35
best_method = None  # 初始化为None，表示未找到最好的方法
36
best_f1 = 0  # 初始化F1分数
37

38
# 寻找最好的K和weights
39
for method in ['uniform', 'distance']:  # weights默认是uniform，参数可以是uniform、distance
40
    for i in range(1, 11):
41
        knn_clf = KNeighborsClassifier(n_neighbors=i, weights=method)
42
        
43
        # 进行10折交叉验证，返回F1分数
44
        cv_scores = cross_val_score(knn_clf, x_train, y_train, cv=10, scoring='f1_macro')  # 使用macro平均方式计算F1分数
45
        mean_f1_score = cv_scores.mean()  # 计算交叉验证的平均F1分数
46

47
        # 更新最佳F1分数和K值、权重方法
48
        if mean_f1_score > best_f1:
49
            best_f1 = mean_f1_score
50
            best_k = i
51
            best_method = method
52

53
print('最好的K值:%d, 最好的F1分数:%.4f, 最好的方法:%s' % (best_k, best_f1, best_method))

朴素贝叶斯算法

朴素贝叶斯算法的基本原理

（1）朴素贝叶斯算法的原理

朴素贝叶斯算法（Naive Bayes，NB）是一种基于概率统计的简单高效的机器学习分类器，基于贝叶斯定理和特征条件独立性假设，用于解决分类问题。朴素贝叶斯算法的核心思想可以简单概括为：倒推，即在给定一组特征的情况下，根据已知类别的数据计算每一个类别的后验概率，然后选择具有最大后验概率的类别作为预测结果。

后验概率（Posterior Probability），是指某件事已经发生，计算事情发生是由某个因素引起的概率；先验概率（Prior Probability），是指根据以往经验和分析，在实验或采样前就可以得到的概率。

举个例子。

假如发生了凶杀案，需要我们找到凶手。 此时我们可以根据过往的案子中“有类似情况时，嫌疑人通常是谁”，从而推断凶手，这个过程就是朴素贝叶斯。

当然，朴素贝叶斯是个被美化的翻译。“朴素”原词是“navie”，即天真的。朴素贝叶斯算法之所以“天真”，是其假定特征之间相互独立，即在给定类别的情况下，特征之间没有关联性（现实中几乎不存在完全相互独立的特征，所以这种算法其实是十分“天真”的设定）。但这样做的好处在于，能够使计算后的概率更加简化，从而提高计算效率。

（2）数学描述

设定输入空间$X\subseteq R^n$$X\subseteq R^n$为$n$$n$维向量的集合，输出空间维类标记集合$Y=c_1,,c_2,...,c_i,...,c_k$$Y={c_1, ,c_2,...,c_i,...,c_k}$，输入特征向量$x\in X$$x \in X$，输出空间分类标记$y\in Y$$y \in Y$。训练集数据$T=(x_1,y_1),(x_2,y_2),...,(x_n,y_n)$$T={(x_1,y_1),(x_2,y_2),...,(x_n,y_n)}$，$P(X,Y)$$P(X,Y)$独立同分布。其条件独立性为：

朴素贝叶斯使用后验概率：